package com.rfid.common.utils;


import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Maps;
import com.google.common.reflect.TypeToken;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonNull;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;


/**
 *  google转换json对象
 * @author  eric
 * @date 2020-07-20
 */
@Component
public class ObjectConversion {
    private final Gson gson = new GsonBuilder()
            .serializeNulls()
            .registerTypeAdapter(JSONObject.class, new MapTypeAdapter())
            .registerTypeAdapter(Map.class, new MapTypeAdapter())
            .setDateFormat("yyyy-MM-dd HH:mm:ss").create();

    /**
     * 从List<A> copy到List<B>
     * @param list List<B>
     * @param clazz B
     * @return List<B>
     */
    public <T> List<T> copy(List<?> list, Class <T> clazz){
        String oldOb=gson.toJson(list);
        return jsonStrToList(oldOb,clazz);

    }

    /**
     * 从对象A copy到 对象B
     * @param source 源对象
     * @param target 目标对象
     * @return 目标对象 class
     */
    public <T> T copy(Object source,Class<T> target){
        String oldOb=gson.toJson(source);
        return gson.fromJson(oldOb,target);
    }

    /**
     * 对象转json字符串
     * @param source :将要被转化的对象
     * @return :转化后的JSON字符串
     */
    public String objectToJsonStr(Object source) {
        if (source == null) {
            return gson.toJson(JsonNull.INSTANCE);
        }
        return gson.toJson(source);
    }
    /**
     * json字符串转对象 <T>
     * @param jsonStr  json 字符串
     * @param clazz    转换成的对象
     * @return clazz对象
     */
    public <T> T jsonStrToObject(String jsonStr,Class <T> clazz){
        return gson.fromJson(jsonStr, clazz);
    }
    /**
     * json字符串转List<T>
     * @param jsonStr json自字符串
     * @param clazz   转换的List<对象>
     * @return List<T>
     */
    @SuppressWarnings("UnstableApiUsage")
    public <T> List<T> jsonStrToList(String jsonStr, Class <T> clazz){

        List<T> listT = null;
        try {
            List<Object> listObj;
            listObj = new GsonBuilder().create().fromJson(jsonStr, new TypeToken<List<Object>>(){}.getType());
            listT = new ArrayList<>();
            //将Object的list中的的每一个元素中的json字符串转换为泛型代表的类型加入泛型代表的list集合返回
            for (Object obj : listObj) {
                T perT = gson.fromJson(gson.toJson(obj), clazz);
                listT.add(perT);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return listT;
    }

    /**
     * 复制map对象
     * @explain 将paramsMap中的键值对全部拷贝到resultMap中；
     * paramsMap中的内容不会影响到resultMap（深拷贝）
     * @param paramsMap
     *     被拷贝对象
     * @param resultMap
     *     拷贝后的对象
     */
    public void copyMap(Map paramsMap, Map resultMap) {
        if (resultMap == null) {
            resultMap = Maps.newHashMap();
        }
        if (paramsMap == null) {
            return;
        }
        Iterator it = paramsMap.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            Object key = entry.getKey();
            resultMap.put(key, paramsMap.get(key) != null ? paramsMap.get(key) : "");

        }
    }
}
